﻿//

#ifndef HISFX3PLATFORM_H
#define HISFX3PLATFORM_H

#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(_WIN64)
#ifdef HISFX3PLATFORM_EXPORTS
#define HISFX3PLATFORM_API __declspec(dllexport)
#else
#define HISFX3PLATFORM_API __declspec(dllimport)
#endif

#else  // windows
#define HISFX3PLATFORM_API 
#endif

#include "HisGlobalDefine.h"

#ifdef __cplusplus
extern "C"
{
#endif

namespace RBOXAPI
{
//! 设置工装型号
/*!
\param[in] boxType 
\param[in] camCount 模组数量
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3SetCurrentPlatformType(_HisFX3_Platform_Type boxType);
HISFX3PLATFORM_API int HisFX3SetCurrentPlatformTypeByBoxIndex(_HisFX3_Platform_Type box_type, int box_index);

HISFX3PLATFORM_API _HisFX3_Platform_Type HisFX3GetCurrentPlatformType();
HISFX3PLATFORM_API _HisFX3_Platform_Type HisFX3GetCurrentPlatformTypeByBoxIndex(int box_index);

/**
 * \~Chinese
 * @brief 设置每个工装所用的光纤数量
 * 
 * @param[in] num 光纤数量
 * 
 * \~English
 * @brief Set the number of fibers used for each box.
 * 
 * @param[in] num Number of fibers
 * 
 * \~
 * @return 
 * @sa HisFX3GetCurrentFiberNum
 */
HISFX3PLATFORM_API void HisFX3SetFiberNum(int num);

/**
 * \~Chinese
 * @brief 设置每个工装所用的光纤数量
 * 
 * @param[in] box_index 工装编号
 * 
 * \~English
 * @brief Obtain the actual number of fibers used by box.
 * 
 * @param[in] box_index Box Index
 * 
 * \~
 * @return Number of fibers
 * @sa HisFX3SetFiberNum
 */
HISFX3PLATFORM_API int HisFX3GetCurrentFiberNum(int box_index);

//! 对普通万兆网卡的绑核核仿射情况进行设置
/*! 
\param[in] coreBandMethod 对绑核情况进行判断
	0: 自动模式。对服务器CPU+WIN10以上系统，要求绑核；其他则要求不绑核；
	1：不判断
	2：要求不绑核
	3：要求绑核
\param[in] affinityMethod 在绑核的条件设置是否要进行进程仿射
	0：自动模式。处于绑核的条件下仿射；反之则不仿射；
	1：不仿射
\sa
*/
HISFX3PLATFORM_API void HisFX3SetNormal10GNICRssMethod(int coreBandMethod, int affinityMethod);

	//! 设置万兆网卡类型
	/*! 
	\param[in] type  0：标准万兆网卡；1：Rolongo自制PCIe加速卡 X1；
	\sa
	*/
	HISFX3PLATFORM_API void HisFX3SetGbEType(int type);

	//! 获取工装数量
	/*! 
	\return 工装个数
	\sa HisFX3EnumDev
	*/
	HISFX3PLATFORM_API int HisFX3GetDevCount();

	//! 枚举在线的工装设备
	/*! 之后必须调用HisFX3EnumFree释放资源，否则会造成内存泄漏
	\param[out] dev 工装唯一序列号列表
	\param[out] devCount 在线的工装数量
	\return 0:成功  非0:失败
	\sa HisFX3EnumFree
	*/
	HISFX3PLATFORM_API int HisFX3EnumDev(char*** dev, int* devCount);

	//! 释放HisFX3EnumDev中开辟的内存
	/*!
	\param[in] dev 工装唯一序列号列表
	\param[in] devCount 工装数量
	\sa HisFX3EnumDev
	*/
	HISFX3PLATFORM_API void HisFX3EnumFree(char** dev, int devCount);

	//! 枚举在线的工装设备，作用和HisFX3EnumDev一样，只是返回的格式不同
	/*! 
	\param[out] dev 工装唯一序列号列表，多个序列号之间用";"隔开；内存需要用户自己申请，建议不少于256Bytes;
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3EnumDevStr(char* dev);

	//! 打开工装dev, 编号为boxIndex, 编号不能超过_RMAX_BOXS-1
	/*!
	\param[in] boxIndex 工装编号
	\param[in] dev 工装唯一序列号, 如果为NULL，则不比对序列号，随机打开一个工装
	\return 0:成功  非0:失败
	\sa HisFX3CloseDevice
	*/
	HISFX3PLATFORM_API int HisFX3OpenDevice(int boxIndex = 0, char* dev = 0);

	//! 关闭工装
	/*!
	\param[in] boxIndex 工装编号, 如何为-1则关闭所有工装
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3CloseDevice(int boxIndex = 0);

	//! 获取HisFX3OpenDevice打开的工装的序列号
	/*!
	\param[out] dev 如果函数成功，返回当前的工装序列号；至少需要申请64Byte内存大小；
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa HisFX3EnumDev, HisFX3EnumFree
	*/
	HISFX3PLATFORM_API int HisFX3GetCurrentBoxSerial(char* dev, int boxIndex = 0);

	//! 在线升级FPGA固件
	/*!
	\param[in] binPath 升级文档路径
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3UpdateFPGA(char* binPath, int boxIndex = 0);

	//! 在线升级PCIe光纤加速卡固件
	/*!
	\param[in] binPath 升级文档路径
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3UpdatePCIeFiber(char* binPath);

	//! 设置光纤加速卡一根光纤线上的最大模组数量
	/*!
	\param[in] maxCamsPerFiber 一根光纤线上的最大模组数量
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetPCIeFiberMaxCamsPerFiber(int maxCamsPerFiber, int boxIndex = 0);

	//! 调节工装上传速率，对R10S, USB3.0工装有效(必须在OpenDevice成功之后调用)
	/*!
	\param[in] speed 0~10000, 0表示最小速率， 10000表示最大速率
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetUSBSpeed(uint32_t speed, int boxIndex = 0);

	//! 设置USB收发包的大小(R5, S5)
	/*!
	\param[in] size 单位：16KB
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetUSBPktSize(uint32_t size, int boxIndex = 0);

	//! 获取工装FPGA版本号
	/*!
	\param[in] boxIndex 工装编号
	\return 版本号
	\sa
	*/
	HISFX3PLATFORM_API uint32_t HisFX3GetFPGAVer(int boxIndex = 0);

	//! 获取工装开短路固件版本号
	/*!
	\param[in] boxIndex 工装编号
	\return 版本号
	\sa
	*/
	HISFX3PLATFORM_API uint32_t HisFX3GetOSVer(int boxIndex = 0);

	//! 获取工装SOC LINUX系统版本号
	/*!
	\param[in] boxIndex 工装编号
	\return 版本号
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3GetSOCVer(int boxIndex = 0);

	//! 获取工装FX3固件版本号
	/*!
	\param[in] boxIndex 工装编号
	\return 版本号
	\sa
	*/
	HISFX3PLATFORM_API uint32_t HisFX3GetFX3Ver(int boxIndex = 0);

	//! 获取PCIe加速卡固件版本号
	/*!
	\return 版本号
	\sa
	*/
	HISFX3PLATFORM_API uint32_t HisFX3GetPCIeFiberCardVer();

	//! 获取PCIe加速卡驱动版本号
	/*!
	\return 版本号
	\sa
	*/
	HISFX3PLATFORM_API uint32_t HisFX3GetPCIeCardDriverVer();

	//! 工装是否已经打开
	/*!
	\param[in] boxIndex 工装编号
	\return true: 已打开   false:还未打开
	\sa
	*/
	HISFX3PLATFORM_API bool HisFX3IsOpen(int boxIndex = 0);

	//! 测试通信链接是否正常
	/*! 一般情况用HisFX3IsOpen
	\param[in] boxIndex 工装编号
	\return true: 已打开   false:还未打开
	\sa
	*/
	HISFX3PLATFORM_API bool HisFX3IsConnected(int boxIndex = 0);


	//! 控制工装上LED的状态
	/*!
	\param[in] on true: 闪烁  false:灭
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int  HisFX3LedControl(bool on, int boxIndex = 0);

	//! 控制工装上蜂鸣器的状态
	/*!
	\param[in] on true: 开  false:关
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3BuzzerControl(bool on, int boxIndex = 0);

	//! 控制工装上风扇的运行模式
	/*!
	\param[in] mode 0：自动  1：开  2：关
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetFanMode(uint32_t mode, int boxIndex = 0);

	//! 设置风扇自动模式的高/低温度
	/*! 
	\param[in] low 温度< low时关闭
	\param[in] high 温度> high时打开
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetFanAutoRange(double low, double high, int boxIndex = 0);

	//! 设置风扇电压
	/*!
	\param[in] v 电压，单位：V
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetFanVolt(double v, int boxIndex = 0);

	//! 测试当前工装总电流
	/*!
	\param[out] current 返回测试到的当前电流值，单位:mA
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3MeasureBoxTotalCurrent(double* current, int boxIndex = 0);
	
	//! 获取工装内FPGA当前温度
	/*!
	\param[in] boxIndex 工装编号
	\return 温度， 单位：摄氏度
	\sa
	*/
	HISFX3PLATFORM_API double HisFX3GetFPGATemperature(int boxIndex = 0);

	HISFX3PLATFORM_API int HisFX3GetFPGAStatus(char* status, int bufSize, int boxIndex = 0);

	//! 获取PCIe加速卡内FPGA当前温度
	/*!
	\return 温度， 单位：摄氏度
	\sa
	*/
	HISFX3PLATFORM_API double HisFX3GetPCIeFirberCardTemperature();

	//! 烧写用户自定义数据到工装Flash
	/*! 空间大小：8KB; 
	\param[in] reg 寄存器地址，从0x0开始
	\param[in] data 要烧写的数据Buffer
	\param[in] dataSize 数据长度
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3BurnUserData(uint32_t reg, uint8_t* data, uint32_t dataSize, int boxIndex = 0);

	//! 从工装Flash读取用户数据
	/*! 空间大小：8KB;
	\param[in] reg 寄存器地址，从0x0开始
	\param[in] data 要烧写的数据Buffer
	\param[in] dataSize 数据长度
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3ReadUserData(uint32_t reg, uint8_t* data, uint32_t dataSize, int boxIndex = 0);



	//! FPGA是否开启DDR缓存功能
	/*!
	\param[in] on true : 开启； false:关闭；
	\param[in] cam 模组编号
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetDDR(bool on, int cam = 0);

	//! 是否只输出正确帧
	/*!
	\param[in] onlyRightFrame b0: 设置FPGA;  b1: 设置上位机;
	\param[in] cam 模组编号
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3OnlyRightFrame(uint8_t onlyRightFrame, int cam = 0);

	//! 开始出图
	/*!
	\param[in] p 点亮相关参数
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_PreviewStruct
	*/
	HISFX3PLATFORM_API int HisFX3StartPreview(_HisFX3_PreviewStruct* p, int cam = 0);

	//! 开始出图
	/*!
	\param[in] iniPath INI参数文件路径，路径名不能有中文字符
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa 
	*/
	HISFX3PLATFORM_API int HisFX3StartPreview_INI(char* iniPath, int cam = 0);

	//! 停止出图
	/*!
	\param[in] sequence 下电时序，设置为NULL时，则采用默认下电时序
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3StopPreview(char *sequence, int cam);

	//! 不下电，切换图像尺寸
	/*!
	\param[in] p 必要的参数，按需配置, 一般需要配RESET,MCLK,port,iic,dataFormat,width,height,cphyRate
	\param[in] sequence 配置时序，如果设为NULL，则启用默认时序
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SwitchImageSize(_HisFX3_PreviewStruct* p, char* sequence, int cam);


	//! 设置图像接口信息
	/*!
	\param[in] port 图像数据接口类型
	\param[in] lanes 图像数据通道数量
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_MIPILane_Stream
	*/
	HISFX3PLATFORM_API int HisFX3SetPortCfg(_HisFX3_MIPILane_Stream port, uint8_t lanes, int cam = 0);

	//! 设置图像数据流映射模式
	/*!
	\param[in] map_mode 映射模式
	\param[in] custom_data 保留
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa HisFX3BoxVideoStreamMapMode
	*/
	HISFX3PLATFORM_API int HisFX3SetBoxVideoStreamMapMode(HisFX3BoxVideoStreamMapMode map_mode, uint64_t custom_data, int cam);

	//! 重置图像接口解码模块
	/*!
	\param[in] port 图像数据接口类型
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_MIPILane_Stream
	*/
	HISFX3PLATFORM_API int HisFX3ResetPortDecoder(_HisFX3_MIPILane_Stream port, int cam = 0);

	//! 启动/停止图像接口解码模块, 通常建议使用HisFX3ResetPortDecoder
	/*!
	\param[in] port 图像数据接口类型
	\param[in] on 是否启动
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_MIPILane_Stream
	*/
	HISFX3PLATFORM_API int HisFX3PortDecoderOnOff(_HisFX3_MIPILane_Stream port, bool on, int cam = 0);

	//! 获取图像接口解码解码信息
	/*!
	\param[in] port 图像数据接口类型
	\param[in][out] info 解码信息的字符串表示， 内存大小 >= 512Byte
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_MIPILane_Stream
	*/
	HISFX3PLATFORM_API int HisFX3GetDecoderInfo(_HisFX3_MIPILane_Stream port, char* info, int cam = 0);

	//! 设置一帧的图像数据，若为0, 则SDK根据设置的图像宽高自动计算；若为非0，则以此作为判断条件
	/*!
	\param[in] frameBytes 一帧的图像数据大小，单位：Bytes
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_BaylorMode
	*/
	HISFX3PLATFORM_API int HisFX3SetCustomFrameBytes(uint32_t frameBytes, int cam);

	//! 设置FPGA上传的数据类型，在开启虚拟通道上传时有效
	/*!
	\param[in] mode 上传模式，0：全部类型上传；1：只上传指定的数据类型
	\param[in] uploadType 指定上传的数据类型
	\param[in] typeCount 指定上传数据类型的数量
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetUploadPktType(uint8_t mode, uint8_t* uploadType, uint32_t typeCount, int cam);

	//! 设置上传图像数据的帧信息
	/*!
	\param[in] dataFormat 图像数据格式
	\param[in] width 图像宽， 不包含dummyLeft, dummyRight	
	\param[in] height 图像宽， 不包含dummyTop, dummyBottom
	\param[in] dummyLeft 图像左边需要裁掉的列数
	\param[in] dummyRight 图像右边需要裁掉的列数
	\param[in] dummyTop 图像上边需要裁掉的行数
	\param[in] dummyBottom 图像下边需要裁掉的行数
	\param[in] addInfoBytes; 保留，固定设为0
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_BaylorMode
	*/
	HISFX3PLATFORM_API int HisFX3SetFrameCfg(_HisFX3_BaylorMode dataFormat, int width, int height,  \
		int dummyLeft=0, int dummyRight=0, int dummyTop=0, int dummyBottom=0, int addInfoBytes = 0, int cam = 0);
	
	//! 设置分区块上传的ROI，调此函数之前需调用HisFX3SetFrameCfg
	/*! 
	\param[in] streamROI ROI坐标，单位：像素；坐标必须为偶数；如果是HisFX3GrabFrame取Compact格式, 则必须满足Compact的格式需求
	\param[in] nums ROI数量，范围[0, _RMAX_STREAM_ROI_NUMS]
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa HisFX3SetFrameCfg
	*/
	HISFX3PLATFORM_API int HisFX3SetUpStreamROI(RRect* streamROI, int nums, int cam = 0);

	//! 开启图像数据抓取线程
	/*!
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3StartCapture(int cam = 0);

	//! 忽略frames帧之后开启图像数据抓取线程, **此API已过时， 建议使用HisFX3StartDelayCapture**
	/*!
	\param[in] frames 忽略的帧数
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3StartCaptureWithSkip(uint32_t frames, int cam = 0);

	//! 设置延时抓帧的方式
	/*!
	\param[in] cfg 参数
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_DelayGrab
	*/
	HISFX3PLATFORM_API int HisFX3StartDelayCapture(_HisFX3_DelayGrab cfg, int cam = 0);

	//! 停止图像数据抓取线程
	/*!
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3StopCapture(int cam = 0);

	HISFX3PLATFORM_API int HisFX3SetDataUploadStreamOnOff(bool on, int cam);

	//! 设置图像数据上传模式
	/*!
	\param[in] mode 图像数据上传模式
	\param[in] cam 模组编号
	\param[in] autoOffTime 单位：ms; 当模式设为自动模式时，连续超过autoOffTime时间未调用HisFX3GrabFrame时，则关闭图像数据上传
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetImageStreamMode(_HisFX3_IMAGE_STREAM_MODE mode, uint32_t autoOffTime, int cam = 0);

	//! 模组是否已开始出图
	/*!
	\param[in] cam 模组编号
	\return true: 正在出图 false: 没有出图
	\sa
	*/
	HISFX3PLATFORM_API bool HisFX3IsStart(int cam = 0);

	//! 图像数据是否正在上传
	/*!
	\param[in] waitTime 等待时间，单位:ms
	\param[in] cam 模组编号
	\return true: 正在上传 false: 没有正在上传
	\sa
	*/
	HISFX3PLATFORM_API bool HisFX3IsDataUploading(uint32_t waitTime, int cam = 0);

	//! 抓取一帧图像
	/*!
	\param[in] imageBuf 存取图像数据的内存指针
	\param[in] bufSize imageBuf大小， 单位：Byte
	\param[out] frameIndex 帧索引
	\param[out] errorFrame 是否为错误帧
	\param[out] recSize 收到的数据大小，单位：Byte
	\param[in] imageFormat 图像数据格式，如果和SENSOR格式不一致，会自动转化为imageFormat格式; 0表示和输入保持一致
	\param[in] timeout 等待时间
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3GrabFrame(uint8_t* imageBuf, int bufSize, uint32_t* frameIndex, bool* errorFrame, uint32_t* recSize, uint32_t imageFormat=0, uint32_t timeout = 2000, int cam = 0);

	/*! 抓取一帧图像
	\param[in] grabCfg 
	\param[out] grabRel 
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_GrabFrame_Cfg _HisFX3_GrabFrame_Rel
	*/
	HISFX3PLATFORM_API int HisFX3GrabFrameStruct(_HisFX3_GrabFrame_Cfg* grabCfg, _HisFX3_GrabFrame_Rel* grabRel, int cam);

	//! 获取当前帧索引
	/*!
	\param[out] rightFrame 总的正确帧数
	\param[out] errFrame 总的错误帧数
	\param[in] flag 0: FPGA接收到的总帧数， 1：PC收到的总帧数
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3GetTotalFrame(uint32_t* rightFrame, uint32_t* errFrame, uint32_t flag, int cam = 0);

//! 获取FPS
/*!
\param[out] rightFPS 正确帧FPS
\param[out] errFrame 错误帧FPS
\param[in] flag 0: FPGA接收到的FPS， 1：PC收到的FPS
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3GetFPS(double* rightFPS, double* errFPS, uint32_t flag, int cam = 0);

//! 设置FPS的计算方式
/*!
\param[in] calculate_method 0: 上位机计算， 1：FPGA计算
\sa
*/
HISFX3PLATFORM_API void HisFX3SetFPSCalculateMethod(int calculate_method);

/**
 * \~Chinese
 * @brief 设置时间戳源。
 * 
 * @param[in] source 时间戳源
 * @param[in] gps_uart_baud_rate 用于GPS同步源的UART波特率
 * @param[in] box_index 工装索引
 * 
 * \~English
 * @brief Set the timestamp source.
 * 
 * @param[in] source timestamp source
 * @param[in] gps_uart_baud_rate UART baud rate for GPS synchronization sources 
 * @param[in] box_index box index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3FPGATimeStampSourceType
 */
HISFX3PLATFORM_API int HisFX3SetFPGAFrameTimeStampSource(HisFX3FPGATimeStampSourceType source, uint32_t gps_uart_baud_rate, int box_index);

/**
 * \~Chinese
 * @brief 给FPGA设置帧间隔阈值时间。
 * 
 * @param[in] max_frame_interval_time 最大帧间隔时间。 单位: us
 * @param[in] reserve 
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief The frame interval threshold time is set to the FPGA.
 * 
 * @param[in] max_frame_interval_time Maximum frame interval time. unit: us
 * @param[in] reserve 
 * @param[in] cam camera index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3GetFPS HisFX3GetFPGAFrameIntervalStatistics
 */
HISFX3PLATFORM_API int HisFX3SetFPGAFrameIntervalThresold(uint32_t max_frame_interval_time, uint32_t reserve, int cam);

/**
 * \~Chinese
 * @brief 获取FPGA统计的帧间隔时间信息。
 * 
 * @param[out] min_frame_interval_time 最小帧间隔时间
 * @param[out] max_frame_interval_time 最大帧间隔时间
 * @param[out] frame_loss_count 丢失的帧数量
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Get the frame interval time statistics of the FPGA.
 * 
 * @param[out] min_frame_interval_time Minimum frame interval time
 * @param[out] max_frame_interval_time Maximum frame interval time
 * @param[out] frame_loss_count The number of frames lost
 * @param[in] cam camera index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3SetFPGAFrameIntervalThresold HisFX3GetFPS
 */
HISFX3PLATFORM_API int HisFX3GetFPGAFrameIntervalStatistics(uint32_t* min_frame_interval_time, uint32_t* max_frame_interval_time, uint32_t* frame_loss_count, int cam);

	//! 清除统计信息
	/*!
	\param[out] type 需要清除统计的信息类型，支持 | 操作; 支持变量请查看_HisFX3_Statistics_Type
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_Statistics_Type
	*/
	HISFX3PLATFORM_API int HisFX3ClearStastisticInfomation(uint32_t type, int cam = 0);

	//! 获取连续帧， 注意：先要关闭DDR的功能，才能保证连续；
	/*!
	\param[in] imageBuf 一个指针数组的指针
	\param[in] frames 连续帧帧数
	\param[in] imageFormat 图像数据格式，如果和SENSOR格式不一致，会自动转化为imageFormat格式; 0表示和输入保持一致
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	sample code:
	uint8_t** buf = NULL;
	HisFX3GrabConsecutiveFrames(&buf, 5, 0, 0);
	*/
	HISFX3PLATFORM_API int HisFX3GrabConsecutiveFrames(uint8_t*** imageBuf, uint32_t frames, uint32_t imageFormat, int cam);

	//! 释放HisFX3GrabConsecutiveFrames中开启的连续帧内存
	/*!
	\param[in] imageBuf 一个指针数组的指针
	\param[in] frames 连续帧帧数
	\sa
	*/
	HISFX3PLATFORM_API void HisFX3ConsecutiveFramesFree(uint8_t*** imageBuf, uint32_t frames);

	//! 抓取同步帧
	/*!
	\param[in] imageBuf 一个指针数组, 用户需要自己开辟内存
	\param[in] imageFormat 图像数据格式，如果和SENSOR格式不一致，会自动转化为imageFormat格式; 0表示和输入保持一致
	\param[in] cams 需要抓取的模组通道，bit0表示cam 0，以此类推
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3GrabSyncFrames(uint8_t* imageBuf[], uint32_t imageFormat, uint32_t cams, int boxIndex = 0);

	//! 开启IIC SCL低电平最大持续时间
	/*!
	\param[in] ms 单位：ms
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int SetSCLLowMaxTime(uint32_t ms, int cam);

	//! 开启IIC 自动ACK模式
	/*! 开启之后，当ACK没有响应时，会循环侦测一段时间，直到ACK有响应或者timeout
	\param[in] enable 开启/关闭 IIC自动ACK模式
	\param[in] timeout 单位：ms
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3EnableIICAutoAck(bool enable, uint32_t timeout, int cam = 0);

	//! 检测自动ACK模式是否已经开启
	/*! 
	\param[in] cam 模组编号
	\return 非0：开启，返回等待时间；0：未开启
	\sa
	*/
	HISFX3PLATFORM_API uint32_t HisFX3IsIICAutoAckEnabled(int cam = 0);

//! 设置控制通道通信协议
/*!
\param[in] protocal 详见_HisFX3_CommunicationProtocal
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa _HisFX3_CommunicationProtocal
*/
HISFX3PLATFORM_API int HisFX3SetControlCommunicationProtocal(_HisFX3_CommunicationProtocal protocal, int cam = 0);

//! 设置IIC速率
/*!
\param[in] speed IIC速率， 单位：KHz
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3SetIICSpeed(uint32_t speed, int cam = 0);

	//! 获取当前IIC速率
	/*!
	\param[in] cam 模组编号
	\return 当前IIC速率， 单位：KHz
	\sa
	*/
	HISFX3PLATFORM_API uint32_t HisFX3GetIICSpeed(int cam = 0);

	//! 测试IIC ACK是否有响应
	/*!
	\param[in] slave 设备地址
	\param[in] cam 模组编号
	\return true: 有响应， false: 没有响应
	\sa
	*/
	HISFX3PLATFORM_API bool HisFX3IICResponds(uint8_t slave, int cam = 0);

	//! 等待IIC响应， 直至timeout或者IIC有响应
	/*!
	\param[in] slave 设备地址
	\param[in] timeout 单位:ms
	\param[in] cam 模组编号
	\return true: 有响应， false: 没有响应
	\sa
	*/
	HISFX3PLATFORM_API bool HisFX3WaitIICResponds(uint8_t slave, uint32_t timeout, int cam = 0);

	//! 单条IIC写入
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] ack 是否判定ACK响应
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3WriteIIC(uint8_t slave, uint32_t reg, uint64_t data, uint16_t type, bool ack = true, int cam = 0);

	//! 单条IIC读取
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[out] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3ReadIIC(uint8_t slave, uint32_t reg, uint64_t* data, uint16_t type, int cam = 0);

	//! 批量IIC写入
	/*!
	\param[in] count IIC条数
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] delay 每条IIC写入之间的间隔时间， 单位:us
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3BatchWriteIICNoLimit(uint32_t count, uint8_t* slave, uint32_t* reg, uint32_t* data, uint16_t* type, uint16_t delay = 10, int cam = 0);

//! 批量IIC读取
/*!
\param[in] count IIC条数
\param[in] slave 设备地址
\param[in] reg 寄存器地址
\param[out] data 数据
\param[in] type 类型: 0x0808, 0x1608, 0x1632...
\param[in] delay 每条IIC读取之间的间隔时间， 单位:us
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3BatchReadIICNoLimit(uint32_t count, uint8_t* slave, uint32_t* reg, uint32_t* data, uint16_t* type, uint16_t delay = 10, int cam = 0);

//! 单条触发模组IIC写入
/*!
\param[in] slave 设备地址
\param[in] reg 寄存器地址
\param[in] regSize 寄存器地址大小， 单位： Byte
\param[in] data 数据
\param[in] dataSize 数据大小， 单位： Byte (R5X,R6:最大512)
\param[in] delay 每个Byte之间的间隔延时， 单位：半个SCL时钟周期
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3PageWriteIIC(uint32_t slave, uint32_t reg, uint32_t regSize, uint8_t* data, uint32_t dataSize, uint16_t delay = 4, int cam = 0);

//! 单条触发模组IIC写入, 更多的参数配置
/*!
\param[in] slave 设备地址
\param[in] reg 寄存器地址
\param[in] reg_size 寄存器地址大小， 单位： Byte
\param[in] data 数据
\param[in] data_size 数据大小， 单位： Byte (R5X,R6:最大512)
\param[in] ack 是否要检查ACK
\param[in] stop_signal 结束之后是否要发送STOP信号
\param[in] byte_delay 每个Byte之间的间隔延时， 单位：半个SCL时钟周期
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3PageWriteIICExtend(uint32_t slave, uint64_t reg, uint32_t reg_size, uint8_t* data, uint32_t data_size, bool ack, bool stop_signal, uint16_t byte_delay, int cam);

//! 单条触发模组IIC读取
/*!
\param[in] slave 设备地址
\param[in] reg 寄存器地址
\param[in] regSize 寄存器地址大小， 单位： Byte
\param[out] data 数据
\param[in] dataSize 数据大小， 单位： Byte (R5X,R6:最大512)
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3PageReadIIC(uint32_t slave, uint32_t reg, uint32_t regSize, uint8_t* data, uint32_t dataSize, int cam = 0);


/**
 * \~Chinese
 * @brief 为I3C设备的静态地址分配动态地址。
 * 
 * @param[in] static_slave 静态地址
 * @param[in] dynamic_slave 动态地址
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Assign dynamic addresses to the static addresses of I3C devices.
 * 
 * @param[in] static_slave static address
 * @param[in] dynamic_slave dynamic address
 * @param[in] cam camera index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3SetI3CBroadcastOnOff
 */
HISFX3PLATFORM_API int HisFX3AssignI3CDynamicAddressToStaticAddress(uint32_t static_slave, uint32_t dynamic_slave, int cam);

/**
 * \~Chinese
 * @brief 开启/关闭 I3C广播地址。
 * 
 * @param[in] on 开启/关闭 I3C广播地址
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Enables/disables I3C broadcast address.
 * 
 * @param[in] on Enables/disables I3C broadcast address
 * @param[in] cam camera index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3AssignI3CDynamicAddressToStaticAddress
 */
HISFX3PLATFORM_API int HisFX3SetI3CBroadcastOnOff(bool on, int cam);

	//! 设置I3C速率
	/*!
	\param[in] speed I3C速率， 单位：KHz
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetI3CSpeed(uint32_t speed, int cam);

	//! 单条触发I3C写入
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] reg_size 寄存器地址大小， 单位： Byte
	\param[in] data 数据
	\param[in] data_size 数据大小， 单位： Byte
	\param[in] ack 是否要检测设备ACK
	\param[in] stop_signal 保留，设为true
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3PageWriteI3C(uint32_t slave, uint64_t reg, uint32_t reg_size, uint8_t* data, uint32_t data_size, bool ack, bool stop_signal, int cam);
	
	//! 单条触发I3C读取
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] reg_size 寄存器地址大小， 单位： Byte
	\param[out] data 数据
	\param[in] data_size 数据大小， 单位： Byte
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3PageReadI3C(uint32_t slave, uint64_t reg, uint32_t reg_size, uint8_t* data, uint32_t data_size, int cam);
	
	//! 单条I3C写入
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] data 数据
	\param[in] data_mask 保留， 设为0
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] ack 是否要检测设备ACK
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3WriteI3C(uint32_t slave, uint64_t reg, uint64_t data, uint64_t data_mask, uint16_t type, bool ack, int cam);

	//! 单条I3C读取
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[out] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3ReadI3C(uint32_t slave, uint64_t reg, uint64_t* data, uint16_t type, int cam);

	//! 批量I3C写入
	/*!
	\param[in] num I3C条数
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] data 数据
	\param[in] data_mask 保留，设为NULL
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] delay 每条I3C写入之间的间隔时间， 单位:us
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3BatchWriteI3CNoLimit(uint32_t num, uint8_t* slave, uint32_t* reg, uint32_t* data, uint32_t* data_mask, uint16_t* type, uint16_t delay, int cam);
	
	//! 批量I3C读取
	/*!
	\param[in] num I3C条数
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[out] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] delay 每条I3C读取之间的间隔时间， 单位:us
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3BatchReadI3CNoLimit(uint32_t num, uint8_t* slave, uint32_t* reg, uint32_t* data, uint16_t* type, uint16_t delay, int cam);

	//! 批量触发模组IIC写入, SDK实现
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] regSize 寄存器地址大小， 单位： Byte
	\param[in] data 数据
	\param[in] dataSize 数据大小， 单位： Byte
	\param[in] pageSize 单次触发写入的数据大小， 单位： Byte (R5X,R6:最大512)
	\param[in] byteDelay 每个Byte之间的间隔延时， 单位：半个SCL时钟周期
	\param[in] pageDelay 每次触发写入之间的间隔时间，单位:ms
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3PageWriteIICNoLimit(uint32_t slave, uint32_t reg, uint32_t regSize, uint8_t* data, uint32_t dataSize, uint32_t pageSize, uint16_t byteDelay = 4, uint32_t pageDelay = 100, int cam = 0);

	//! 批量触发模组IIC读取, SDK实现
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] regSize 寄存器地址大小， 单位： Byte
	\param[out] data 数据
	\param[in] dataSize 数据大小， 单位： Byte
	\param[in] pageSize 单次触发写入的数据大小， 单位： Byte (R5X,R6:最大512)
	\param[in] pageDelay 每次触发写入之间的间隔时间，单位:ms
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3PageReadIICNoLimit(uint32_t slave, uint32_t reg, uint32_t regSize, uint8_t* data, uint32_t dataSize, uint32_t pageSize, uint32_t pageDelay = 0, int cam = 0);

	//! 批量触发模组IIC读写， FPGA实现
	/*!
	\param[inout] items 
	\param[in] num items数量
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3PageI2CItem
	*/
	HISFX3PLATFORM_API int HisFX3BatchPageWriteReadI2C(_HisFX3PageI2CItem* items, int num, int cam);

	//! SONY车载芯片Command IIC读写
	/*!
	\param[in] slave 设备地址
	\param[in] code 命令代码(Command Code)
	\param[in] writeBuf 需要写入的数据
	\param[in] writeSize 需要写入的数据大小， 单位: Byte
	\param[in] delay 写入和回读之间的延时等待时间， 单位:us
	\param[out] readBuf 如果是读操作，会把读取到的数据存到此buffer
	\param[in] readSize 如果是读操作，填读取的大小，否则填0； 单位: Byte
	\param[out] status 命令执行结果状态代码
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SONYCommandIIC(uint32_t slave, uint8_t code, uint8_t* writeBuf, uint32_t writeSize, uint32_t delay, uint8_t* readBuf, uint32_t readSize, uint8_t* status, int cam = 0);
	
	//! 设置SPI的速率
	/*!
	\param[in] speed SPI速率，单位：KHz
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetSPISpeed(uint32_t speed, int cam = 0);

	//! 获取当前SPI的速率
	/*!
	\param[in] cam 模组编号
	\return 当前SPI速率，单位:KHz
	\sa
	*/
	HISFX3PLATFORM_API uint32_t HisFX3GetSPISpeed(int cam = 0);

	//! 单条SPI写入
	/*!
	\param[in] slave 设备地址，当设0xFF时， 不操作设备地址
	\param[in] reg 寄存器地址
	\param[in] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] csLow CS信号是否拉低
	\param[in] littleEndian 1个BYTE内的BIT排序是否地位在前
	\param[in] clkHigh true: CLK默认是在高电平；false: CLK默认是在低电平；需要R2C >= 3506
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3WriteSPI(uint8_t slave, uint32_t reg, uint64_t data, \
		uint16_t type, bool csLow = true, bool littleEndian = true, bool clkHigh = true, int cam = 0);

	//! 单条SPI读取
	/*!
	\param[in] slave 设备地址，当设0xFF时， 不操作设备地址
	\param[in] reg 寄存器地址
	\param[out] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] csLow CS信号是否拉低
	\param[in] littleEndian 1个BYTE内的BIT排序是否地位在前
	\param[in] clkHigh true: CLK默认是在高电平；false: CLK默认是在低电平；需要R2C >= 3506
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3ReadSPI(uint8_t slave, uint32_t reg, uint64_t* data, \
		uint16_t type, bool csLow = true, bool littleEndian = true, bool clkHigh = true, int cam = 0);

	//! 单条触发SPI写入
	/*!
	\param[in] slave 设备地址，当设0xFF时， 不操作设备地址
	\param[in] reg 寄存器地址
	\param[in] regSize 寄存器地址大小， 单位： Byte
	\param[in] data 数据
	\param[in] dataSize 数据大小， 单位： Byte (R5X,R6:最大512)
	\param[in] csLow CS信号是否拉低
	\param[in] littleEndian 1个BYTE内的BIT排序是否地位在前
	\param[in] clkHigh true: CLK默认是在高电平；false: CLK默认是在低电平；需要R2C >= 3506
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3PageWriteSPI(uint8_t slave, uint32_t reg, uint32_t regSize, \
		uint8_t* data, uint32_t dataSize, bool csLow = true, bool littleEndian = true, bool clkHigh = true, int cam = 0);

	//! 单条触发SPI读取
	/*!
	\param[in] slave 设备地址，当设0xFF时， 不操作设备地址
	\param[in] reg 寄存器地址
	\param[in] regSize 寄存器地址大小， 单位： Byte
	\param[out] data 数据
	\param[in] dataSize 数据大小， 单位： Byte (R5X,R6:最大512)
	\param[in] csLow CS信号是否拉低
	\param[in] littleEndian 1个BYTE内的BIT排序是否地位在前
	\param[in] clkHigh true: CLK默认是在高电平；false: CLK默认是在低电平；需要R2C >= 3506
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int  HisFX3PageReadSPI(uint8_t slave, uint32_t reg, uint32_t regSize, \
		uint8_t* data, uint32_t dataSize, bool csLow = true, bool littleEndian = true, bool clkHigh = true, int cam = 0);

	//! 设置UART参数
	/*!
	\param[in] bautRate 波特率，单位： Hz
	\param[in] OddEvenCheck 奇偶校验。 0：无校验；1：奇校验；2：偶校验
	\param[in] stopBit 停止位。0:1 bit；1: 1.5 bit；2: 2 bit
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetUARTCfg(int bautRate, int OddEvenCheck, int stopBit, int cam);

	//! UART写入
	/*!
	\param[in] data 需要写入的内存地址
	\param[in] len 需要写入的大小，单位：Byte
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3WriteUART(uint8_t* data, uint32_t len, int cam);

	//! 清除UART RX FIFO
	/*!
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3ClearUARTRxFIFO(int cam);

	//! UART读取
	/*!
	\param[out] data 读取数据存入的内存地址
	\param[out] len 读取到的数据大小，单位：Byte
	\param[in] maxLen 读取的最大数据量，读取数量超过maxLen，则函数返回。单位：Byte
	\param[in] timeOut 最大等待时间。单位：ms
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3ReadUART(uint8_t* data, uint32_t* len, int maxLen, int timeOut, int cam);

	//! 设置每路电压的连接模式
	/*!
	\param[in] standby BIT位 1: 是静态模式，连接电阻为100欧  0: 是工作模式，连接电阻为0.1欧
	\param[in] flag 通道选择,支持位|操作， _HisFX3_Platform_VoltFlag
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_Platform_VoltFlag
	*/
	HISFX3PLATFORM_API int HisFX3SetVoltLinkMode(uint32_t standby, uint32_t flag, int cam = 0);

	//! 设置电压
	/*!
	\param[in] volt 电压, 单位：V。Ps. 5V,12V通道设置的方式： -1.0(不设置), 0.0(关闭), 1.0(打开)
	\param[in] flag 通道选择， _HisFX3_Platform_VoltFlag
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_Platform_VoltFlag
	*/
	HISFX3PLATFORM_API int HisFX3SetVolt(float volt, uint32_t flag, int cam = 0);

	//! 获取当前设置的电压
	/*!
	\param[in] flag 通道选择， _HisFX3_Platform_VoltFlag
	\param[in] cam 模组编号
	\return 当前设置的电压, 单位：V
	\sa _HisFX3_Platform_VoltFlag
	*/
	HISFX3PLATFORM_API float HisFX3GetVoltSetted(_HisFX3_Platform_VoltFlag flag, int cam = 0);

	//! 测量当前的输出电压值
	/*!
	\param[in] flag 通道选择， _HisFX3_Platform_VoltFlag
	\param[in] cam 模组编号
	\return 当前设置的电压, 单位：V
	\sa _HisFX3_Platform_VoltFlag
	*/
	HISFX3PLATFORM_API float HisFX3ReadVolt(_HisFX3_Platform_VoltFlag flag, int cam = 0);

	//! 电源接地放电
	/*!
	\param[in] channel 保留
	\param[in] ms 放电时间，单位:ms
	\param[in] cam 模组编号
	\return 当前设置的电压, 单位：V
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3VoltDischarge(uint32_t channel, uint32_t ms, int cam = 0);

	//! 设置电压反馈点
	/*!
	\param[in] nearFeedback 是否为内反馈
	\param[in] channel 通道选择， _HisFX3_Platform_VoltFlag
	\param[in] cam 模组编号
	\return 当前设置的电压, 单位：V
	\sa _HisFX3_Platform_VoltFlag
	*/
	HISFX3PLATFORM_API int HisFX3SetVoltFeedbackPoint(bool nearFeedback, _HisFX3_Platform_VoltFlag channel, int cam = 0);

	//! 设置MCLK
	/*!
	\param[in] mclk频率， 单位:MHz
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetMCLK(double mclk, int cam = 0);

	//! 获取当前设置的MCLK
	/*!
	\param[in] cam 模组编号
	\return 当前设置的MCLK， 单位:MHz
	\sa
	*/
	HISFX3PLATFORM_API double HisFX3GetMCLK(int cam = 0);

//! 设置RESET信号电平
/*!
\param[in] high 是否拉高
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3PullReset(bool high, int cam = 0);

	//! 设置PWDN信号电平
	/*!
	\param[in] high 是否拉高
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3PullPWDN(bool high, int cam = 0);

	//! 设置并口采集同步信号相移
	/*!
	\param[in] ps  0:不相移;  1: 90度;  2: 180度;  3: 270度;
	\param[in] cam 模组编号
	\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetPhaseShift_DVP(int ps, int cam = 0);

	//! 设置并口参数
	/*!
	\param[in] dvpLineFormat   0：采9:2   1: 采7:0   2：采15:0   3：采9:0  4：采11:0   5：采13:0
	\param[in] vsHigh  VS 同步信号设置。   true: 高电平有效；   false: 低电平有效---[注1：VC8D无效]
	\param[in] ps  采集同步信号相移  0:不相移;  1: 90度;  2: 180度;  3: 270度;---[注1：VC8D无效]
	\param[in] cam 模组编号
	\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetDVP(uint32_t dvpLineFormat, bool vsHigh, int ps, int cam = 0);

	//! 设置LVDS需要做数据对齐的通道
	/*!
	\param[in] pixAlign  b0:1表示通道1需要对齐， 以此类推...
	\param[in] cam 模组编号
	\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetPixelAlign_LVDS(uint32_t pixAlign, int cam = 0);

	//! 设置LVDS XVS,XVS信号
	/*!
	\param[in] on  true:需要输出XHS, XVS;		false:不需要输出XHS, XVS;
	\param[in] xhs
	\param[in] xvs
	\param[in] cam 模组编号
	\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetXVSXHS_LVDS(bool on, uint32_t xhs, uint32_t xvs, int cam = 0);

	//! 设置DPHY XVS,XVS信号(R5X支持)
	/*!
	\param[in] on  true:需要输出XHS, XVS;		false:不需要输出XHS, XVS;
	\param[in] xhs
	\param[in] xvs
	\param[in] cam 模组编号
	\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetXVSXHS_DPHY(bool on, uint32_t xhs, uint32_t xvs, int cam = 0);

//! 设置DPHY信号采集模式
/*!
\param[in] mode   0: Power Down  1: SLVS 2:D-PHY
\param[in] cam 模组编号
\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
\sa _HisFX3Platform_ErrorCode
*/
HISFX3PLATFORM_API int HisFX3SetSignalMode_DPHY(uint32_t mode, int cam = 0);

/**
 * \~Chinese
 * @brief 设置DPHY接收是否打开deskew 功能。
 * 
 * @param[in] on true: 开启； flase: 关闭
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Set whether the deskew function is turned on for DPHY reception.
 * 
 * @param[in] on true: on; flase: off
 * @param[in] cam camera index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa 
 */
HISFX3PLATFORM_API int HisFX3SetDPHYDeskewOnOff(bool on, int cam);

	//! 设置HISPI协议的高低位bit是否需要反转
	/*! 支持的版本: R5X(ver>=2019)
	\param[in] on   true: 反转  false: 不反转
	\param[in] cam 模组编号
	\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetBitReverse_HiSPI(bool on, int cam = 0);

	//! 设置是否解码MIPI信号的虚拟通道数据
	/*!
	\param[in] on  true: 解码  false:不解码
	\param[in] cam 模组编号
	\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetVirtualChannel_MIPI(bool on, int cam = 0);

	//! 设置CPHY的速率
	/*!
	\param[in] rate  速率；单位：Gbps；支持范围：(0.1~1.6)(1.96~2.5)
	\param[in] cam 模组编号
	\return 0:成功  非0:失败 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetDataRate_CPHY(double rate, int cam = 0);

	//! 搜索CPHY的速率，只有在出图状态下，并且CPHY模式为9线模式才能调用
	/*!
	\param[in] rs  搜索范围的起始频率；单位：Gbps；支持范围：(0.1~1.6)(1.96~2.5)
	\param[in] re  搜索范围的结束频率；单位：Gbps；支持范围：(0.1~1.6)(1.96~2.5)
	\param[in] step  每次搜索步进的频率；单位：Gbps；
	\param[in] cam 模组编号
	\return CPHY的速率，单位：Gbps； <0表示搜索出错或者不满足条件 ==0表示搜索不到
	\sa
	*/
	HISFX3PLATFORM_API double HisFX3MeasureDataRate_CPHY(double rs, double re, double step, int cam = 0);

	//! 自动调整范围和STEP值搜索CPHY速率
	/*!
	\param[in] cam 模组编号
	\return CPHY的速率，单位：Gbps； <=0表示搜索不到
	\sa
	*/
	HISFX3PLATFORM_API double HisFX3AutoMeasureCPHYRate(int cam = 0);

	//! 设置CPHY信号寄存器
	/*!
	\param[in] slave 设备地址,第一级：0xA0,0xA2,0xA4; 第二级:0xB0,0xB2,0xB4
	\param[in] reg 寄存器地址
	\param[in] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3WriteSigCfg_CPHY(uint8_t slave, uint32_t reg, uint64_t data, uint16_t type, int cam = 0);
	
	//! 读取CPHY信号寄存器
	/*!
	\param[in] slave 设备地址,第一级：0xA0,0xA2,0xA4; 第二级:0xB0,0xB2,0xB4
	\param[in] reg 寄存器地址
	\param[out] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3ReadSigCfg_CPHY(uint8_t slave, uint32_t reg, uint64_t* data, uint16_t type, int cam=0);
	
	//! 设置CPHY的工作模式
	/*!
	\param[in] mode 0:带参考时钟  1:不带参考时钟
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SetMode_CPHY(uint32_t mode, int cam = 0);

	HISFX3PLATFORM_API int HisFX3SetFPGARXCM_CPHY(int mode, int trim, int cam = 0);

	//! 电流测量
	/*!
	\param[out] current 测试的电流数据，至少申请10个的数组大小，结果排序依次为AVDD,DVDD,DOVDD,AF,OTP,POW,AVDDB,AVDDC,PVDD,NVDD,OTPEXT
	\param[in] flag 电源通道，_HisFX3_Platform_VoltFlag，支持 | 操作
	\param[in] precision 精度设置， 0：mA, 1:uA, 2:nA
	\param[in] samples 取平均值的采样次数
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_Platform_VoltFlag
	*/
	HISFX3PLATFORM_API int HisFX3MeasureCurrent(double current[], uint32_t flag, uint32_t precision, uint32_t samples = 256, int cam = 0);

	//! 设置连续测量电流模式
	/*!
	\param[in] voltage_channel_flag 电源通道，_HisFX3_Platform_VoltFlag，支持 | 操作
	\param[in] on true: 开启； false: 关闭
	\param[in] sample_interval_time 采样间隔时间，单位：ms
	\param[in] current_range 电流范围， 单位： mA
	\param[in] precision 精度设置， 0：mA, 1:uA, 2:nA
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_Platform_VoltFlag， HisFX3MeasureContinouseCurrent
	*/
	HISFX3PLATFORM_API int HisFX3SetContinouseCurrentTestMode(uint32_t voltage_channel_flag, bool on, double sample_interval_time, double current_range, uint32_t precision, int cam = 0);

	//! 连续测量电流
	/*!
	\param[in] voltage_channel 电源通道，不支持 | 操作
	\param[out] current 测试的电流数据数组
	\param[in] sample_number 采样次数
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_Platform_VoltFlag， HisFX3SetContinouseCurrentTestMode
	*/
	HISFX3PLATFORM_API int HisFX3MeasureContinouseCurrent(_HisFX3_Platform_VoltFlag voltage_channel, double* current, int sample_number, int cam = 0);

	//! 获取OS测试的PIN脚名称列表
	/*!
	\param[out] pin PIN脚名称， 用户申请的数组大小 >= 100
	\param[out] num 实际的PIN脚数量
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
 	HISFX3PLATFORM_API int HisFX3GetOSPinNameList(char pin[][_HisFX3_OS_PinName_MaxByte], int* num, int port, int cam = 0);

	//! OS测试源选择
	/*!
	\param[in] src	0: 恒流源   1: 恒压源
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetOSSource(int src, int cam = 0);

	//! 正向测试
	/*!
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] pin 测试PIN脚
	\param[in] num 测试PIN脚数量
	\param[in] delay 电流稳定延时, 单位: us
	\param[in] current 电源设置。如果为恒流源，单位为mA；如果为恒压源，单位为mV。
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa  _HisFX3OS_Positive_Item
	*/
 	HISFX3PLATFORM_API int HisFX3OSPositiveTest(int port, _HisFX3OS_Positive_Item pin[], int num, uint32_t delay = 1000, float current = 1.3, int cam = 0);

	//! 负向测试
	/*!
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] pin 测试PIN脚
	\param[in] num 测试PIN脚数量
	\param[in] delay 电流稳定延时, 单位: us
	\param[in] current 电源设置。如果为恒流源，单位为mA；如果为恒压源，单位为mV。
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3OS_Negtive_Item
	*/
 	HISFX3PLATFORM_API int HisFX3OSNegtiveTest(int port, _HisFX3OS_Negtive_Item pin[], int num, uint32_t delay = 1000, float current = 1.3, int cam = 0);

	//! 短路测试
	/*!
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] pin 测试PIN脚测试
	\param[in] num 测试PIN脚数量
	\param[in] delay 电流稳定延时, 单位: us
	\param[in] current 电源设置。如果为恒流源，单位为mA；如果为恒压源，单位为mV。
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _RBOXOS_Short_Item
	*/
 	HISFX3PLATFORM_API int HisFX3OSShortTest(int port, _HisFX3OS_Short_Item pin[], int num, uint32_t delay = 1000, float current = 1.3, int cam = 0);

	//! 开路测试
	/*!
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] pin 测试PIN脚测试
	\param[in] num 测试PIN脚数量
	\param[in] delay 电流稳定延时, 单位: us
	\param[in] current 电源设置。如果为恒流源，单位为mA；如果为恒压源，单位为mV。
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3OS_Open_Item
	*/
 	HISFX3PLATFORM_API int HisFX3OSOpenTest(int port, _HisFX3OS_Open_Item pin[], int num, uint32_t delay = 1000, float current = 1.3, int cam = 0);

	//! 电阻测试
	/*!
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] pin 测试PIN脚测试
	\param[in] delay 电流稳定延时, 单位: us
	\param[in] current 电流大小设置，单位：mA
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3OS_OHM_Item
	*/
 	HISFX3PLATFORM_API int HisFX3OSOhmTest(int port, _HisFX3OS_OHM_Item* pin, uint32_t delay = 1000, float current = 1.3, int cam = 0);

	//! VB版本电阻测试
	/*!
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] pin 测试PIN脚测试
	\param[in] num 待测PIN脚数量
	\param[in] theoreticalResistanceValue 理论电阻值，程序会根据这个值选择适合的量程。单位：欧姆
	\param[in] delay 电流稳定延时, 单位: us
	\param[in] inputVoltage 输入电源，单位： mV
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3OS_OHM_Item
	*/
	HISFX3PLATFORM_API int HisFX3OSOhmTest_VB(int port, _HisFX3OS_OHM_Item_VB pin[], int num, double theoreticalResistanceValue, uint32_t delay, float inputVoltage, int cam = 0);

	//! 电压值上升时间测试
	/*!
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] pin 测试PIN脚测试
	\param[in] current 电流大小设置，单位：mA
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3OS_UpTime_Item
	*/
	HISFX3PLATFORM_API int HisFX3OSUpTimeTest(int port, _HisFX3OS_UpTime_Item* pin, float current = 0.1, int cam = 0);

	//! 用OS板测试漏电流
	/*!
	\param[in] port 接口设置， 0：DPHY  1:CPHY  2:DVP 3:LVDS
	\param[in] pin 待测PIN脚设置
	\param[in] num 待测PIN脚数量
	\param[in] delay 电流稳定延时, 单位: us
	\param[in] volt 恒压源电压，单位:mV, 范围：(200~3300mV)，精度：0.8058mV / LSB
	\param[in] currenRange 电流量程选择, 
							0: 量程：4uA, 精度：0.0009768uA / LSB
							1: 量程：40uA, 精度：0.009768uA / LSB
							2: 量程：400uA, 精度：0.09768uA / LSB
							3: 量程：4mA, 精度：0.9768uA / LSB
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3OS_LeakageCurrent_Item
	*/
	HISFX3PLATFORM_API int HisFX3OSLeakageCurrentTest(int port, _HisFX3OS_LeakageCurrent_Item pin[], int num, uint32_t delay, float volt, int currenRange, int cam = 0);

	//! 输出IO口控制， 拉高电平 == IODD
	/*!
	\param[in] status IO输出状态，以BIT位来管理， 1拉高， 0拉低
	\param[in] flag 要操作的输出IO， 以BIT位来管理， 1要操作， 0不操作
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3IO_OutPortWrite(uint32_t status, uint32_t flag, int cam = 0);

	//! 输出IO口状态读取， 拉高电平 == IODD
	/*!
	\param[out] status IO输出状态，以BIT位来管理， 1拉高， 0拉低
	\param[in] flag 要读取的输出IO， 以BIT位来管理， 1要读取， 0不读取
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3IO_OutPortRead(uint32_t* status, uint32_t flag, int cam = 0);

	//! 输入IO口状态读取， 拉高电平 == IODD
	/*!
	\param[out] status IO输出状态，以BIT位来管理， 1拉高， 0拉低
	\param[in] flag 要读取的输出IO， 以BIT位来管理， 1要读取， 0不读取
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3IO_InPortRead(uint32_t* status, uint32_t flag, int cam = 0);

	//! GPIO口输出PWM波形
	/*!
	\param[in] io 需要输入PWM的IO口索引，从0 开始计数
	\param[in] rate 波形频率，单位：KHz
	\param[in] duty 占空比百分比，比如占空比50%就设置50
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetIO_OutPortPWM(uint32_t io, double rate, double duty, int cam = 0);

/**
 * \~Chinese
 * @brief 在规定时间内，统计输入IO的触发次数。
 * 
 * @param[in] io_index 输入IO编号，从0开始计数
 * @param[in] rise_trigger true: 上升沿触发；false: 下降沿触发
 * @param[in] duration 时间长度；单位:ms
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Count the number of triggers of the input IO within the specified time.
 * 
 * @param[in] io_index the IO number and start counting from 0
 * @param[in] rise_trigger true: rising edge trigger；false: falling edge triggering
 * @param[in] duration length of time; unit:ms
 * @param[in] cam camera index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3IO_InPortTriggerStatisticResult
 */
HISFX3PLATFORM_API int HisFX3IO_InPortTriggerStatisticConfig(int32_t io_index, bool rise_trigger, uint32_t duration, int cam);

/**
 * \~Chinese
 * @brief 读取输入IO触发次数
 * 
 * @param[in] io_index 输入IO编号，从0开始计数
 * @param[out] trigger_number 触发次数
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Read the number of input IO triggers
 * 
 * @param[in] io_index the IO number and start counting from 0
 * @param[out] trigger_number number of triggers
 * @param[in] cam camera index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3IO_InPortTriggerStatisticConfig
 */
HISFX3PLATFORM_API int HisFX3IO_InPortTriggerStatisticResult(int32_t io_index, uint32_t* trigger_number, int cam);


	//! 设置SENSOR IIC线连接或断开
	/*!
	\param[in] on true: 链接； false: 断开
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3ConnectSensorIIC(bool on, int cam = 0);

	//! 设置SENSOR IIC线连接状态
	/*!
	\param[in] type
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa _HisFX3_CommunicationProtocal
	*/
	HISFX3PLATFORM_API int HisFX3SetSensorIICConnectType(_HisFX3_CommunicationProtocal type, int cam = 0);

/**
 * \~Chinese
 * @brief 电压校准， 校准值会自动写入工装寄存区
 * 
 * @param[in] box_index 工装编号
 * 
 * \~English
 * @brief Voltage calibration, calibration value will be automatically written to EEProm/Flash
 * 
 * @param[in] box_index Grabber box index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3CurrentCalibration, HisFX3SerializerBoardVoltageCalibration
 */
HISFX3PLATFORM_API int HisFX3VoltCalibration(int box_index = 0);

/**
 * \~Chinese
 * @brief 串化板电压校准， 校准值会自动写入工装寄存区
 * 
 * @param[in] box_index 工装编号
 * @param[out] rel_desc 校准结果， eg: "1,0"
 * 
 * \~English
 * @brief Serializer board voltage calibration, calibration value will be automatically written to EEProm/Flash
 * 
 * @param[in] box_index Grabber box index
 * @param[out] rel_desc Calibration Result， eg: "1,0"
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3VoltCalibration
 */
HISFX3PLATFORM_API int HisFX3SerializerBoardVoltageCalibration(char* rel_desc, int box_index = 0);

	//! 电流校准， 校准值会自动写入工装寄存区
	/*!
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3CurrentCalibration(int boxIndex = 0);

	//! VB版电流校准， 校准值会自动写入工装寄存区
	/*!
	\param[in] r 外接电阻，建议采用精度在千分之一以上，阻值在200K以上的电阻
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3CurrentCalibrationVB(double r, int boxIndex = 0);

	//! 工作电流内阻校准
	/*!
	\param[in] r 外接电阻，建议采用精度在千分之一以上
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3WorkCurrentResistorCalibration(double r, int boxIndex = 0);


	//! 电阻测试校准， 校准值会自动写入工装寄存区
	/*!
	\param[in] r 外接电阻，建议采用精度在千分之一以上
	\param[in] boxIndex 工装编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3OhmTestCalibration(double r, int boxIndex = 0);

/**
 * \~Chinese
 * @brief 设置LOG打印等级
 * 
 * @param[in] log_level LOG打印等级。
 * 
 * \~English
 * @brief Set LOG print level
 * 
 * @param[in] log_level LOG print level.
 * 
 * \~
 * @sa HisFX3LogLevel
 */
HISFX3PLATFORM_API void HisFX3SetLogLevel(HisFX3LogLevel log_level);

	//! 以字符串命令的形式执行非常规操作
	/*!
	\param[in] cmd eg: cmd:current calibration; 就是执行电流校准
	\param[in] p 根据cmd不同， 定义不同
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3CmdExec(char* cmd, void* p = NULL, int* size = NULL, int cam = 0);

	//! 多个进程操作同一个工装
	/*! 使用方法HisFX3SetCurrentPlatformType-->HisFX3SplitBox-->HisFX3OpenDevice
	\param[in] processCount 进程数量
	\param[in] processIndex 进程索引
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SplitBox(uint32_t processCount, uint32_t processIndex);

	//! 设置UVC数据源格式
	/*! 
	\param[in] srcFormat 必须大写 eg. "H264", "MJPG", "YUYV", "UYVY"
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3SetSrcFormat_UVC(char* srcFormat, int cam = 0);

	//! UVC模组通用控制
	/*!
	\param[in] propertyName 需要控制的属性名称
	\param[in] propertyValue 设置值，设置的值必须在允许值返回之类，允许值可以通过amcap查看，或者通过HisFX3GetNormalProperty_UVC获取
	\param[in] autoMode 是否开启自动模式
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa UVC_CAPTURE_PROPETIES
	*/
	HISFX3PLATFORM_API int HisFX3SetNormalProperty_UVC(UVC_CAPTURE_PROPETIES  propertyName, long propertyValue, bool autoMode, int cam = 0);

	//! 获取UVC模组当前通用属性设定
	/*!
	\param[in] propertyName 需要控制的属性名称
	\param[out] propertyValue 当前属性值
	\param[out] autoMode 是否开启自动模式
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa UVC_CAPTURE_PROPETIES
	*/
	HISFX3PLATFORM_API int HisFX3GetNormalProperty_UVC(UVC_CAPTURE_PROPETIES  propertyName, long* propertyValue, bool* autoMode, int cam = 0);

	//! 设置UVC数据源格式
	/*!
	\param[in] srcFormat 必须大写 eg. "H264", "MJPG", "YUYV", "UYVY"
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3SetXUProperty_UVC(int cam = 0);

	//! 设置UVC数据源格式
	/*!
	\param[in] srcFormat 必须大写 eg. "H264", "MJPG", "YUYV", "UYVY"
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3GetXUProperty_UVC(int cam = 0);

//! 设置解串板型号
/*!
\param[in] deserializer_type 解串板型号
\sa _HisFX3_Deserializer
*/
HISFX3PLATFORM_API void HisFX3SetDeserializerType(uint32_t board_deserializer_type);

/**
 * \~Chinese
 * @brief 设置解串板型号
 * 
 * @param[in] board_deserializer_type 解串板型号
 * @param[in] board_index 解串板索引号(从0开始)； 负数表示对所有的解串板进行设置
 * @param[in] box_index 工装编号
 * 
 * \~English
 * @brief Set deserializer board type
 * 
 * @param[in] board_deserializer_type Deserializer board type
 * @param[in] board_index Deserializer board index number(starting from 0); A negative number indicates that all the deserializer boards are set.
 * @param[in] box_index Index of grabber box
 * 
 * \~
 * @sa _HisFX3_Deserializer
 */
HISFX3PLATFORM_API void HisFX3SetDeserializerTypeEx(_HisFX3_Deserializer board_deserializer_type, int board_index = -1, int box_index = 0);

/**
 * \~Chinese
 * @brief 设置解串板型号
 * 
 * @param[in] board_deserializer_type 解串板型号, 名称和_HisFX3_Deserializer名称一致
 * @param[in] board_index 解串板索引号(从0开始)； 负数表示对所有的解串板进行设置
 * @param[in] box_index 工装编号
 * 
 * \~English
 * @brief Set deserializer board type
 * 
 * @param[in] board_deserializer_type Deserializer board type, name is the same as _HisFX3_Deserializer name
 * @param[in] board_index Deserializer board index number(starting from 0); A negative number indicates that all the deserializer boards are set.
 * @param[in] box_index Index of grabber box
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa _HisFX3_Deserializer
 */
HISFX3PLATFORM_API int HisFX3SetDeserializerTypeStringEx(const char* board_deserializer_type, int board_index = -1, int box_index = 0);

/**
 * \~Chinese
 * @brief 设置串化板型号
 * 
 * @param[in] board_serializer_type 串化板型号
 * @param[in] board_index 串化板索引号(从0开始)； 负数表示对所有的串化板进行设置
 * @param[in] box_index 工装编号
 * 
 * \~English
 * @brief Set serializer board type
 * 
 * @param[in] board_serializer_type Serializer board type
 * @param[in] board_index Serializer board index number(starting from 0); A negative number indicates that all the serializer boards are set.
 * @param[in] box_index Index of grabber box
 * 
 * \~
 * @sa _HisFX3SerializerType
 */
HISFX3PLATFORM_API void HisFX3SetSerializerTypeEx(_HisFX3SerializerType board_serializer_type, int board_index = -1, int box_index = 0);

/**
 * \~Chinese
 * @brief 设置串化板型号
 * 
 * @param[in] board_serializer_type 串化板型号, 名称和_HisFX3SerializerType名称一致
 * @param[in] board_index 串化板索引号(从0开始)； 负数表示对所有的串化板进行设置
 * @param[in] box_index 工装编号
 * 
 * \~English
 * @brief Set serializer board type
 * 
 * @param[in] board_serializer_type Serializer board type, name is the same as _HisFX3SerializerType name
 * @param[in] board_index Serializer board index number(starting from 0); A negative number indicates that all the serializer boards are set.
 * @param[in] box_index Index of grabber box
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa _HisFX3SerializerType
 */
HISFX3PLATFORM_API int HisFX3SetSerializerTypeStringEx(const char* board_serializer_type, int board_index = -1, int box_index = 0);

//! 设置解串芯片连接方式
/*!
\param[in] type
\param[in] cam 模组编号
\sa _HisFX3_Deserializer_Connect_Type
*/
HISFX3PLATFORM_API int HisFX3SetDeserializerConnectType(_HisFX3_Deserializer_Connect_Type type, int cam = 0);

//! 设置解串芯片工作模式
/*!
\param[in] mode
\param[in] cam 模组编号
\sa _HisFX3_Deserializer_Mode
*/
HISFX3PLATFORM_API int HisFX3SetDeserializerMode(_HisFX3_Deserializer_Mode mode, int cam = 0);

//! 设置解串芯片设备地址
/*!
\param[in] slave: 设备地址。TI954包含{0x60,0x64,0x68,0x6C,0x70,0x74,0x78,0x7C}
\param[in] cam 模组编号
\sa
*/
HISFX3PLATFORM_API int HisFX3SetDeserializerSlaveAddress(uint8_t slave, int cam = 0);

/**
 * \~Chinese
 * @brief 获取解串芯片的PASS/LOCK信号统计信息
 * 
 * @param[out] pass_count:	PASS 信号触发次数
 * @param[out] lock_count:	LOCK 信号触发次数
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Obtain statistical information on PASS/LOCK signals for the deserializer chip
 * 
 * @param[out] pass_count Number of PASS signal triggers
 * @param[out] lock_count Number of LOCK signal triggers
 * @param[in] cam cam module index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3GetDeserializerPassLockLevel
 */
HISFX3PLATFORM_API int HisFX3GetDeserializerPassLockStatistics(uint32_t* pass_count, uint32_t* lock_count, int cam = 0);

/**
 * \~Chinese
 * @brief 获取解串芯片的PASS/LOCK信号电平状态
 * 
 * @param[out] is_pass_io_high PASS 信号电平状态
 * @param[out] is_lock_io_high LOCK 信号电平状态
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Get the PASS/LOCK signal level status of the deserializer chip
 * 
 * @param[out] is_pass_io_high PASS signal level status
 * @param[out] is_lock_io_high LOCK signal level status
 * @param[in] cam cam module index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3GetDeserializerPassLockStatistics
 */
HISFX3PLATFORM_API int HisFX3GetDeserializerPassLockLevel(bool* is_pass_io_high, bool* is_lock_io_high, int cam = 0);

	//! 解串芯片第二组I2C单条写入
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] ack 是否判定ACK响应
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3DeserializerWriteI2CChannel2(uint8_t slave, uint32_t reg, uint64_t data, uint16_t type, bool ack = true, int cam = 0);

	//! 解串芯片第二组I2C单条读取
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[out] data 数据
	\param[in] ack 是否判定ACK响应
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3DeserializerReadI2CChannel2(uint8_t slave, uint32_t reg, uint64_t* data, uint16_t type, int cam = 0);

	//! 解串芯片第二组I2C批量写入
	/*!
	\param[in] count IIC条数
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] delay 每条IIC写入之间的间隔时间， 单位:us
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3DeserializerBatchWriteIICNoLimitChannel2(uint32_t count, uint8_t* slave, uint32_t* reg, uint32_t* data, uint16_t* type, uint16_t delay = 10, int cam = 0);

	//! 解串芯片第二组I2C批量读取
	/*!
	\param[in] count IIC条数
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[out] data 数据
	\param[in] type 类型: 0x0808, 0x1608, 0x1632...
	\param[in] delay 每条IIC读取之间的间隔时间， 单位:us
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3DeserializerBatchReadIICNoLimitChannel2(uint32_t count, uint8_t* slave, uint32_t* reg, uint32_t* data, uint16_t* type, uint16_t delay = 10, int cam = 0);

	//! 解串芯片第二组I2C单条触发写入
	/*!
	\param[in] slave 设备地址
	\param[in] reg 寄存器地址
	\param[in] regSize 寄存器地址大小， 单位： Byte
	\param[in] data 数据
	\param[in] dataSize 数据大小， 单位： Byte (R5X,R6:最大512)
	\param[in] delay 每个Byte之间的间隔延时， 单位：半个SCL时钟周期
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3DeserializerPageWriteI2CChannel2(uint32_t slave, uint32_t reg, uint32_t regSize, uint8_t* data, uint32_t dataSize, uint16_t delay = 4, int cam = 0);

//! 解串芯片第二组I2C单条触发读取
/*!
\param[in] slave 设备地址
\param[in] reg 寄存器地址
\param[in] regSize 寄存器地址大小， 单位： Byte
\param[out] data 数据
\param[in] dataSize 数据大小， 单位： Byte (R5X,R6:最大512)
\param[in] cam 模组编号
\return 0:成功  非0:失败
\sa
*/
HISFX3PLATFORM_API int HisFX3DeserializerPageReadIICChannel2(uint32_t slave, uint32_t reg, uint32_t regSize, uint8_t* data, uint32_t dataSize, int cam = 0);

	//! 设置VM16F解串芯片的输入时钟
	/*!
	\param[in] mclk: 单位： MHz
	\sa
	*/
	HISFX3PLATFORM_API void HisFX3SetDeserializerMCLK_VM16F(double mclk);

	//! 开启/关闭 VM16F16模组模式
	/*!
	*/
	HISFX3PLATFORM_API void HisFX3SetCamMode16OnOff_VM16F(bool on);

	//! 保留
	HISFX3PLATFORM_API int HisFX3SetPOCVoltage_VM16F(float v, int box_index, uint32_t combined_cam_channel);

	//! 设置图像上传抽点(VC8D)
	/*!
	\param[in] sampleWidth: 图像宽抽点，0-不抽点；其他：间隔sampleWidth个点抽一个点
	\param[in] sampleHeight: 图像高抽点，0-不抽点；其他：间隔sampleWidth个点抽一个点
	\param[in] cam 模组编号
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3SetImageSample_VC8D(uint8_t sampleWidth, uint8_t sampleHeight, int cam = 0);

	//! 改变工装内部器件的I2C设备地址， 避免和模组的I2C设备冲突(VC8D)
	/*!
	\param[in] group2: 是否启用第二组设备地址
	\param[in] cam 模组编号
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3ChangeInternelDeviceSlaveGroup_VC8D(bool group2, int cam = 0);


//! 获取最后的错误描述
/*! 在API返回错误的情况调用
\param[in] cam 模组编号
\return 错误信息指针
*/
HISFX3PLATFORM_API const char* HisFX3GetLastError(int cam = 0);

//! 设置离线图片模式
/*! 
\param[in] on 开启/关闭 离线图片模式
\param[in] path 离线图片的路径
\param[in] cam 模组编号
\return 0:成功  非0:失败
*/
HISFX3PLATFORM_API int HisFX3SetOffLineMode(bool on, char* path = NULL, int cam = 0);

	//! FPGA自动对焦
	/*!
	\param[in] cfg 对焦参数
	\param[out] relt 对焦结果
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3AF(_HisFX3_FPGAAF_Cfg* cfg, _HisFX3_FPGAAF_Rel* relt, int cam = 0);

	//! FPGA自动曝光
	/*!
	\param[in] cfg 自动曝光参数
	\param[out] relt 自动曝光结果
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3AE(_HisFX3_FPGAAE_Cfg* cfg, _HisFX3_FPGAAE_Rel* relt, int cam = 0);

	//! FPGA等待固定帧然后计算单张MTF
	/*!
	\param[in] cfg 参数
	\param[out] mtf 计算的MTF结果值，内存大小最少需要9 *sizeof(double)
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3CalculateSingleFrameMTF(HisFX3SingleFrameMTFCfg* cfg, double* mtf, int cam = 0);

	//! 清除I2C电平测试结果
	/*!
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3ClearI2CSignalResult(int cam = 0);

	//! 读取I2C信号线的电平
	/*!
	\param[in] cfg 参数设置以及测试结果返回
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3ReadI2CSignalLevel(_HisFX3_I2CSignalLevelCheck_Cfg_Rel& cfg, int cam = 0);

	//! 读取图像信号线的电平
	/*!
	\param[in] cfg 参数设置以及测试结果返回
	\param[in] cam 模组编号
	\return 0:成功  非0:失败
	*/
	HISFX3PLATFORM_API int HisFX3ReadSensorSignalLevel(_HisFX3_SensorSignalLevelCheck_Cfg_Rel& cfg, int cam = 0);

/**
 * \~Chinese
 * @brief 设置额外功能转换板型号
 * 
 * @param[in] board_type 额外功能转换板型号
 * @param[in] box_index 工装索引
 * 
 * \~English
 * @brief Set additional function conversion board model
 * 
 * @param[in] board_type Additional function conversion board model
 * @param[in] box_index box index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa HisFX3AdditionalFunctionBoardType
 */
HISFX3PLATFORM_API int HisFX3SetAdditionalFunctionBoardType(HisFX3AdditionalFunctionBoardType board_type, int box_index);

/**
 * \~Chinese
 * @brief 解析INI出图文件
 * 
 * @param[in] ini_file_path INI文件路径
 * @param[out] cfg 点亮参数结构体
 * 
 * \~English
 * @brief Parser INI file of sensor config
 * 
 * @param[in] ini_file_path INI file path
 * @param[out] cfg preview config struct
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa _HisFX3_PreviewStruct
 */
HISFX3PLATFORM_API int HisFX3ParserIniFileToPreviewStruct(const char* ini_file_path, _HisFX3_PreviewStruct* cfg);	

//! 获取离线图片模式的信息
/*! 在开启离线模式的情况下调用
\param[out] width 图像宽
\param[out] height 图像高
\param[out] dataFormat 数据格式
\param[out] frameBytes 一帧图像的数据量大小
\param[in] cam 模组编号
\return true:成功 false:失败
*/
HISFX3PLATFORM_API bool HisFX3GetOfflineModeInfo(uint32_t* width = NULL, uint32_t* height = NULL, _HisFX3_BaylorMode* dataFormat = NULL, uint32_t* frameBytes = NULL, int cam = 0);

// input_mode: 0 带同步时钟； 此时的value: 频率(MHz)
// input_mode: 1 直接外部输入24V; 此时的value: 无意义
HISFX3PLATFORM_API int HisFX3SetInputPowerModeForEMC(int input_mode, double value, int cam);


	HISFX3PLATFORM_API int HisFX3PageOSPositiveTest_SUNNY(uint32_t *puiData, uint32_t uiData, uint32_t *puiData_S2, uint32_t uiData_S2,
		uint32_t *puiData_S3, uint32_t uiData_S3, uint32_t *puiData_S4, uint32_t uiData_S4, uint32_t uiCurrent, uint32_t uiVolt, int boxIndex);

	//! CAM ID转换
	/*!
	\param[in] cam_l 测试硬件ID,从0开始计数,工装1(boxindex(0))->测试盒通道1为0 通道2为1 通道3为2 通道4为3
	\工装2(boxindex(1))->测试盒通道1为4 通道2为5 通道3为6 通道4为7
	\以此类推
	\return  SDK内部cam id
	\sa
	*/
	HISFX3PLATFORM_API int LCamCvt(int cam_l);

	//! 开启工装图像通道
	/*!
	\param[in] boxIndex   工装编号, 设置为0; 仅当1个工装不拆分使用且一个进程拖多个工装才需区分;
	\param[in] processCount  1个工装拆分使用进程(AP)数，可设置4或者2；
	\                                           *当设置为2时(即一个进程2眼模式)，此接口需分时调用不可同时调用或者只调用一次且cam_l设置为偶数;
	\param[in] cam_l       模组ID,从0开始计数,工装1->测试盒通道1为0 通道2为1 通道3为2 通道4为3
	\                                                                      工装2->测试盒通道1为4 通道2为5 通道3为6 通道4为7  以此类推....
	\return  eturn 0:成功  非0:失败的错误代码, 请参考_HisFX3Platform_ErrorCode
	\sa
	*/
	HISFX3PLATFORM_API int HisFX3OpenDevice_LuxVision(int boxIndex, uint32_t processCount, int cam_l);

	HISFX3PLATFORM_API int HisFX3FindRectVA_LuxVision(_HisFX3_LuxVision_FindRect_VA_Cfg* cfg, _HisFX3_LuxVision_FindRect_VA_Rel* ar, int cam);

	//! 切换IIC的控制权
	/*! 上位机在操作IIC之前必须先切换IIC操作权到PC端
	\param[in] source 0: 设定控制权为FPGA;  1: 设定控制权为PC
	\return 0:成功  非0:失败的错误代码, 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3SwitchIICExecSource_Wissen(uint8_t source, int cam);

	//! 获取启动时间和稳像时间的测试状态
	/*! 上位机在操作IIC之前必须先切换IIC操作权到PC端
	\param[out] startComplete 启动时间测试是否完成， true为完成， false为未完成
	\param[out] startTime 启动时间，单位:ms; 只有在startComplete为true的情况下才有意义
	\param[out] stableComplete 稳像时间测试是否完成， true为完成， false为未完成
	\param[out] stableTime 稳像时间，单位:ms; 只有在stableComplete为true的情况下才有意义
	\return 0:成功  非0:失败的错误代码, 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3GetStartTime_Wissen(bool* startComplete, double* startTime, bool* stableComplete, double* stableTime, int cam);

	//! 控制启动时间和稳像时间的测试状态
	/*!
	\param[in] test 0: 测试;  1: 取消测试
	\return 0:成功  非0:失败的错误代码, 请参考_HisFX3Platform_ErrorCode
	\sa _HisFX3Platform_ErrorCode
	*/
	HISFX3PLATFORM_API int HisFX3EnableStartTimeTest_Wissen(uint8_t test ,int cam);

/**
 * \~Chinese
 * @brief 在图像的line_index输出同步信号(定制API)
 * 
 * @param[in] on true： 使能同步信号输出； false：不使能同步信号输出
 * @param[in] line_index 在line_index行输出同步信号(从0开始计数)
 * @param[in] cam 模组编号
 * 
 * \~English
 * @brief Output synchronization signal at image's line_index line(Custom API)
 * 
 * @param[in] on true： Enable synchronization signal output； false：Disable synchronization signal output
 * @param[in] line_index Output synchronization signal at line_index (zero-based)
 * @param[in] cam camera index
 * 
 * \~
 * @return HisFX3Error_Success: Success; others: Error Code.
 * @sa
 */
HISFX3PLATFORM_API int HisFX3SyncTrigger_Gravity(bool on, uint16_t line_index, int cam);

}

namespace RISPAPI
{

HISFX3PLATFORM_API void* malloc_r(size_t size);
HISFX3PLATFORM_API void free_r(void* buf);
HISFX3PLATFORM_API void safe_free_r(void** buf);

	/*! Compact格式的RAW10转成unsigned short表示一个像素的RAW10 */
	HISFX3PLATFORM_API void Cpt2B2_Raw10(void* cptBuf, int width, int height, void* b2Buf);

	/*! Compact格式的RAW转成unsigned short表示一个像素的RAW */
	//! 开启工装图像通道
	/*!
	\param[in] cptBuf   compact raw数据指针；
	\param[in] width  图像宽；
	\param[in] height	 图像高
	\param[in] cptFormat	 RAW数据的具体格式，支持RAW8,RAW10,RAW12,RAW14
	\param[out] b2Buf	 2个BYTE表示一个像素的数据指针
	\return  eturn 0:成功  非0:失败的错误代码, 请参考_HisFX3Platform_ErrorCode
	\sa
	*/
	HISFX3PLATFORM_API int Cpt2B2_RawX(void* cptBuf, int width, int height, _HisFX3_BaylorMode cptFormat, void* b2Buf);

/*! USB工装的虚拟通道RAW数据转成unsigned short表示一个像素的RAW*/
//! 开启工装图像通道
/*!
\param[in] USB工装的虚拟通道RAW数据指针；
\param[in] width  图像宽；
\param[in] height	 图像高
\param[in] cptFormat	 RAW数据的具体格式，支持RAW10,RAW12,RAW14
\param[out] b2Buf	 2个BYTE表示一个像素的数据指针
\return  eturn 0:成功  非0:失败的错误代码, 请参考_HisFX3Platform_ErrorCode
\sa
*/
HISFX3PLATFORM_API int USBBoxVitualChanelConvert(void* buf, int width, int height, _HisFX3_BaylorMode cptFormat, void* b2Buf);

/**
 * \~Chinese
 * @brief 微秒转为时间结构体。
 * 
 * @param[in] us 微秒
 * @param[out] time_struct 时间结构体
 * 
 * \~English
 * @brief Microseconds to time struct.
 * 
 * @param[in] us Microseconds
 * @param[out] time_struct time struct
 * 
 * \~
 * @return 
 * @sa HisFX3TimeStruct
 */
HISFX3PLATFORM_API void TimeStampMicroSecondToTimeStruct(uint64_t us, HisFX3TimeStruct* time_struct);

}


#ifdef  __cplusplus
}
#endif




#endif
